﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using GPSTrackingServerDB.Entities;
using GPSTrackingServerDB.Data;
using GPSTrackingServerDB.Data.Bases;

#endregion

namespace GPSTrackingServerDB.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <see cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("GPSTrackingServerDB.Data") as NetTiersServiceSection;
				}

				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
					return WebConfigurationManager.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name, conn.ConnectionString));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;


			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region WebsiteLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="WebsiteLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static WebsiteLogProviderBase WebsiteLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.WebsiteLogProvider;
			}
		}
		
		#endregion
		
		#region UsersProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Users"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersProviderBase UsersProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersProvider;
			}
		}
		
		#endregion
		
		#region TrackDataProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TrackData"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TrackDataProviderBase TrackDataProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TrackDataProvider;
			}
		}
		
		#endregion
		
		#region StatesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="States"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StatesProviderBase StatesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StatesProvider;
			}
		}
		
		#endregion
		
		#region RolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Roles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RolesProviderBase RolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RolesProvider;
			}
		}
		
		#endregion
		
		#region RolesByUsersProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="RolesByUsers"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RolesByUsersProviderBase RolesByUsersProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RolesByUsersProvider;
			}
		}
		
		#endregion
		
		#region NotificationsLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationsLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsLogProviderBase NotificationsLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsLogProvider;
			}
		}
		
		#endregion
		
		#region NotificationsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Notifications"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsProviderBase NotificationsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsProvider;
			}
		}
		
		#endregion
		
		#region MqLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MqLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MqLogProviderBase MqLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MqLogProvider;
			}
		}
		
		#endregion
		
		#region ListenerLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ListenerLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ListenerLogProviderBase ListenerLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ListenerLogProvider;
			}
		}
		
		#endregion
		
		#region UsersByGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersByGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersByGroupsProviderBase UsersByGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersByGroupsProvider;
			}
		}
		
		#endregion
		
		#region ImeiTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ImeiType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ImeiTypeProviderBase ImeiTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ImeiTypeProvider;
			}
		}
		
		#endregion
		
		#region ImeiProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Imei"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ImeiProviderBase ImeiProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ImeiProvider;
			}
		}
		
		#endregion
		
		#region GroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Groups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GroupsProviderBase GroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GroupsProvider;
			}
		}
		
		#endregion
		
		#region GpsModelsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GpsModels"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GpsModelsProviderBase GpsModelsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GpsModelsProvider;
			}
		}
		
		#endregion
		
		#region GeoFenceDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GeoFenceDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GeoFenceDetailsProviderBase GeoFenceDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GeoFenceDetailsProvider;
			}
		}
		
		#endregion
		
		#region GeoFenceByImeiProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GeoFenceByImei"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GeoFenceByImeiProviderBase GeoFenceByImeiProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GeoFenceByImeiProvider;
			}
		}
		
		#endregion
		
		#region NotificationsByImeiProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationsByImei"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsByImeiProviderBase NotificationsByImeiProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsByImeiProvider;
			}
		}
		
		#endregion
		
		#region GeoFenceProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GeoFence"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GeoFenceProviderBase GeoFenceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GeoFenceProvider;
			}
		}
		
		#endregion
		
		#region PendingComandProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PendingComand"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PendingComandProviderBase PendingComandProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PendingComandProvider;
			}
		}
		
		#endregion
		
		#region GasPricesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GasPrices"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GasPricesProviderBase GasPricesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GasPricesProvider;
			}
		}
		
		#endregion
		
		#region CountriesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Countries"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CountriesProviderBase CountriesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CountriesProvider;
			}
		}
		
		#endregion
		
		#region CitiesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Cities"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CitiesProviderBase CitiesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CitiesProvider;
			}
		}
		
		#endregion
		
		#region AdminRolesByAdminProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdminRolesByAdmin"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdminRolesByAdminProviderBase AdminRolesByAdminProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdminRolesByAdminProvider;
			}
		}
		
		#endregion
		
		#region TrackDataLastLocationProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TrackDataLastLocation"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TrackDataLastLocationProviderBase TrackDataLastLocationProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TrackDataLastLocationProvider;
			}
		}
		
		#endregion
		
		#region AdminRolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdminRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdminRolesProviderBase AdminRolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdminRolesProvider;
			}
		}
		
		#endregion
		
		#region GroupsByImeiProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GroupsByImei"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GroupsByImeiProviderBase GroupsByImeiProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GroupsByImeiProvider;
			}
		}
		
		#endregion
		
		#region AdminProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Admin"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdminProviderBase AdminProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdminProvider;
			}
		}
		
		#endregion
		
		
		#endregion
	}
	
	#region Query/Filters
		
	#region WebsiteLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="WebsiteLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WebsiteLogFilters : WebsiteLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WebsiteLogFilters class.
		/// </summary>
		public WebsiteLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the WebsiteLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WebsiteLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WebsiteLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WebsiteLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WebsiteLogFilters
	
	#region WebsiteLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="WebsiteLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="WebsiteLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WebsiteLogQuery : WebsiteLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WebsiteLogQuery class.
		/// </summary>
		public WebsiteLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the WebsiteLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WebsiteLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WebsiteLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WebsiteLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WebsiteLogQuery
		
	#region UsersFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Users"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersFilters : UsersFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersFilters class.
		/// </summary>
		public UsersFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersFilters
	
	#region UsersQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Users"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersQuery : UsersParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersQuery class.
		/// </summary>
		public UsersQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersQuery
		
	#region TrackDataFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TrackData"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataFilters : TrackDataFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataFilters class.
		/// </summary>
		public TrackDataFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataFilters
	
	#region TrackDataQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TrackDataParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TrackData"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataQuery : TrackDataParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataQuery class.
		/// </summary>
		public TrackDataQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataQuery
		
	#region StatesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="States"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StatesFilters : StatesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StatesFilters class.
		/// </summary>
		public StatesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StatesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StatesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StatesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StatesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StatesFilters
	
	#region StatesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StatesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="States"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StatesQuery : StatesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StatesQuery class.
		/// </summary>
		public StatesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StatesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StatesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StatesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StatesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StatesQuery
		
	#region RolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Roles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RolesFilters : RolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RolesFilters class.
		/// </summary>
		public RolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RolesFilters
	
	#region RolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Roles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RolesQuery : RolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RolesQuery class.
		/// </summary>
		public RolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RolesQuery
		
	#region RolesByUsersFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="RolesByUsers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RolesByUsersFilters : RolesByUsersFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RolesByUsersFilters class.
		/// </summary>
		public RolesByUsersFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RolesByUsersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RolesByUsersFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RolesByUsersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RolesByUsersFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RolesByUsersFilters
	
	#region RolesByUsersQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RolesByUsersParameterBuilder"/> class
	/// that is used exclusively with a <see cref="RolesByUsers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RolesByUsersQuery : RolesByUsersParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RolesByUsersQuery class.
		/// </summary>
		public RolesByUsersQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RolesByUsersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RolesByUsersQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RolesByUsersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RolesByUsersQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RolesByUsersQuery
		
	#region NotificationsLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationsLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsLogFilters : NotificationsLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsLogFilters class.
		/// </summary>
		public NotificationsLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsLogFilters
	
	#region NotificationsLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationsLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsLogQuery : NotificationsLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsLogQuery class.
		/// </summary>
		public NotificationsLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsLogQuery
		
	#region NotificationsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Notifications"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsFilters : NotificationsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsFilters class.
		/// </summary>
		public NotificationsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsFilters
	
	#region NotificationsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Notifications"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsQuery : NotificationsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsQuery class.
		/// </summary>
		public NotificationsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsQuery
		
	#region MqLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MqLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MqLogFilters : MqLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MqLogFilters class.
		/// </summary>
		public MqLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MqLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MqLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MqLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MqLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MqLogFilters
	
	#region MqLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MqLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MqLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MqLogQuery : MqLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MqLogQuery class.
		/// </summary>
		public MqLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MqLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MqLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MqLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MqLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MqLogQuery
		
	#region ListenerLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ListenerLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ListenerLogFilters : ListenerLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ListenerLogFilters class.
		/// </summary>
		public ListenerLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ListenerLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ListenerLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ListenerLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ListenerLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ListenerLogFilters
	
	#region ListenerLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ListenerLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ListenerLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ListenerLogQuery : ListenerLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ListenerLogQuery class.
		/// </summary>
		public ListenerLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ListenerLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ListenerLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ListenerLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ListenerLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ListenerLogQuery
		
	#region UsersByGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersByGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByGroupsFilters : UsersByGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByGroupsFilters class.
		/// </summary>
		public UsersByGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByGroupsFilters
	
	#region UsersByGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersByGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersByGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByGroupsQuery : UsersByGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByGroupsQuery class.
		/// </summary>
		public UsersByGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByGroupsQuery
		
	#region ImeiTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ImeiType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImeiTypeFilters : ImeiTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImeiTypeFilters class.
		/// </summary>
		public ImeiTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImeiTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImeiTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImeiTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImeiTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImeiTypeFilters
	
	#region ImeiTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ImeiTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ImeiType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImeiTypeQuery : ImeiTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImeiTypeQuery class.
		/// </summary>
		public ImeiTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImeiTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImeiTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImeiTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImeiTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImeiTypeQuery
		
	#region ImeiFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Imei"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImeiFilters : ImeiFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImeiFilters class.
		/// </summary>
		public ImeiFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImeiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImeiFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImeiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImeiFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImeiFilters
	
	#region ImeiQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ImeiParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Imei"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImeiQuery : ImeiParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImeiQuery class.
		/// </summary>
		public ImeiQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImeiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImeiQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImeiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImeiQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImeiQuery
		
	#region GroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Groups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupsFilters : GroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupsFilters class.
		/// </summary>
		public GroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupsFilters
	
	#region GroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Groups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupsQuery : GroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupsQuery class.
		/// </summary>
		public GroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupsQuery
		
	#region GpsModelsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GpsModels"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsModelsFilters : GpsModelsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsModelsFilters class.
		/// </summary>
		public GpsModelsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsModelsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsModelsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsModelsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsModelsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsModelsFilters
	
	#region GpsModelsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GpsModelsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GpsModels"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsModelsQuery : GpsModelsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsModelsQuery class.
		/// </summary>
		public GpsModelsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsModelsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsModelsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsModelsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsModelsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsModelsQuery
		
	#region GeoFenceDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GeoFenceDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFenceDetailsFilters : GeoFenceDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsFilters class.
		/// </summary>
		public GeoFenceDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFenceDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFenceDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFenceDetailsFilters
	
	#region GeoFenceDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GeoFenceDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GeoFenceDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFenceDetailsQuery : GeoFenceDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsQuery class.
		/// </summary>
		public GeoFenceDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFenceDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFenceDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFenceDetailsQuery
		
	#region GeoFenceByImeiFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GeoFenceByImei"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFenceByImeiFilters : GeoFenceByImeiFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFenceByImeiFilters class.
		/// </summary>
		public GeoFenceByImeiFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceByImeiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFenceByImeiFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceByImeiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFenceByImeiFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFenceByImeiFilters
	
	#region GeoFenceByImeiQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GeoFenceByImeiParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GeoFenceByImei"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFenceByImeiQuery : GeoFenceByImeiParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFenceByImeiQuery class.
		/// </summary>
		public GeoFenceByImeiQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceByImeiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFenceByImeiQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceByImeiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFenceByImeiQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFenceByImeiQuery
		
	#region NotificationsByImeiFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationsByImei"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsByImeiFilters : NotificationsByImeiFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsByImeiFilters class.
		/// </summary>
		public NotificationsByImeiFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByImeiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsByImeiFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByImeiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsByImeiFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsByImeiFilters
	
	#region NotificationsByImeiQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsByImeiParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationsByImei"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsByImeiQuery : NotificationsByImeiParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsByImeiQuery class.
		/// </summary>
		public NotificationsByImeiQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByImeiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsByImeiQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByImeiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsByImeiQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsByImeiQuery
		
	#region GeoFenceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GeoFence"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFenceFilters : GeoFenceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFenceFilters class.
		/// </summary>
		public GeoFenceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFenceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFenceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFenceFilters
	
	#region GeoFenceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GeoFenceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GeoFence"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFenceQuery : GeoFenceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFenceQuery class.
		/// </summary>
		public GeoFenceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFenceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFenceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFenceQuery
		
	#region PendingComandFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PendingComand"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PendingComandFilters : PendingComandFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PendingComandFilters class.
		/// </summary>
		public PendingComandFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PendingComandFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PendingComandFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PendingComandFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PendingComandFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PendingComandFilters
	
	#region PendingComandQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PendingComandParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PendingComand"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PendingComandQuery : PendingComandParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PendingComandQuery class.
		/// </summary>
		public PendingComandQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PendingComandQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PendingComandQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PendingComandQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PendingComandQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PendingComandQuery
		
	#region GasPricesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GasPrices"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GasPricesFilters : GasPricesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GasPricesFilters class.
		/// </summary>
		public GasPricesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GasPricesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GasPricesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GasPricesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GasPricesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GasPricesFilters
	
	#region GasPricesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GasPricesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GasPrices"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GasPricesQuery : GasPricesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GasPricesQuery class.
		/// </summary>
		public GasPricesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GasPricesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GasPricesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GasPricesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GasPricesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GasPricesQuery
		
	#region CountriesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Countries"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CountriesFilters : CountriesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CountriesFilters class.
		/// </summary>
		public CountriesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CountriesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CountriesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CountriesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CountriesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CountriesFilters
	
	#region CountriesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CountriesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Countries"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CountriesQuery : CountriesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CountriesQuery class.
		/// </summary>
		public CountriesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CountriesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CountriesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CountriesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CountriesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CountriesQuery
		
	#region CitiesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Cities"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CitiesFilters : CitiesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CitiesFilters class.
		/// </summary>
		public CitiesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CitiesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CitiesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CitiesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CitiesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CitiesFilters
	
	#region CitiesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CitiesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Cities"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CitiesQuery : CitiesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CitiesQuery class.
		/// </summary>
		public CitiesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CitiesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CitiesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CitiesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CitiesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CitiesQuery
		
	#region AdminRolesByAdminFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdminRolesByAdmin"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdminRolesByAdminFilters : AdminRolesByAdminFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdminRolesByAdminFilters class.
		/// </summary>
		public AdminRolesByAdminFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdminRolesByAdminFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdminRolesByAdminFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdminRolesByAdminFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdminRolesByAdminFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdminRolesByAdminFilters
	
	#region AdminRolesByAdminQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdminRolesByAdminParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdminRolesByAdmin"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdminRolesByAdminQuery : AdminRolesByAdminParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdminRolesByAdminQuery class.
		/// </summary>
		public AdminRolesByAdminQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdminRolesByAdminQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdminRolesByAdminQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdminRolesByAdminQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdminRolesByAdminQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdminRolesByAdminQuery
		
	#region TrackDataLastLocationFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TrackDataLastLocation"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataLastLocationFilters : TrackDataLastLocationFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationFilters class.
		/// </summary>
		public TrackDataLastLocationFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataLastLocationFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataLastLocationFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataLastLocationFilters
	
	#region TrackDataLastLocationQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TrackDataLastLocationParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TrackDataLastLocation"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataLastLocationQuery : TrackDataLastLocationParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationQuery class.
		/// </summary>
		public TrackDataLastLocationQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataLastLocationQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataLastLocationQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataLastLocationQuery
		
	#region AdminRolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdminRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdminRolesFilters : AdminRolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdminRolesFilters class.
		/// </summary>
		public AdminRolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdminRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdminRolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdminRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdminRolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdminRolesFilters
	
	#region AdminRolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdminRolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdminRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdminRolesQuery : AdminRolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdminRolesQuery class.
		/// </summary>
		public AdminRolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdminRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdminRolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdminRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdminRolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdminRolesQuery
		
	#region GroupsByImeiFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GroupsByImei"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupsByImeiFilters : GroupsByImeiFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupsByImeiFilters class.
		/// </summary>
		public GroupsByImeiFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupsByImeiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupsByImeiFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupsByImeiFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupsByImeiFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupsByImeiFilters
	
	#region GroupsByImeiQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GroupsByImeiParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GroupsByImei"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupsByImeiQuery : GroupsByImeiParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupsByImeiQuery class.
		/// </summary>
		public GroupsByImeiQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupsByImeiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupsByImeiQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupsByImeiQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupsByImeiQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupsByImeiQuery
		
	#region AdminFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Admin"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdminFilters : AdminFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdminFilters class.
		/// </summary>
		public AdminFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdminFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdminFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdminFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdminFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdminFilters
	
	#region AdminQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdminParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Admin"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdminQuery : AdminParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdminQuery class.
		/// </summary>
		public AdminQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdminQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdminQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdminQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdminQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdminQuery
	#endregion

	
}
